﻿/*
Nombre:                         TitularDao
Descripcion:                    Casos de prueba realizados para la clase Electrocucaracha.AdminPersonal.DAO.TitularDao
Dependencias:                 
Fecha de creación:              20081217
Autor:                          VMORALES
Fecha de modifcación:           20080327
Responsable:                    VMORALES
Num. de modifcación:            0
*/

#region Imports

using NUnit.Framework;
using Electrocucaracha.AdminPersonal.DAO.Entidades;
using Spring.Context.Support;
using Spring.Context;
using log4net.Config;
using System.IO;
using System;
using System.Configuration;

#endregion

namespace Electrocucaracha.AdminPersonal.DAO.Test
{
    [TestFixture(Description="Casos de prueba realizados para la clase Electrocucaracha.AdminPersonal.DAO.TitularDao")]
    public class TitularDao : GenericoDao<TitularDao, TitularDTO>
    {
        #region Constantes

        public const string NOMBRES = "Nombres";
        public const string APELLIDO_PATERNO = "ApellidoPaterno";
        public const string APELLIDO_MATERNO = "ApellidoMaterno";
        public const int ID = 1;

        #endregion

        #region Miembros

        public readonly static string INSTANCIA = "TitularDao";
        private ITitularDao dao;

        #endregion

        #region Propiedades

        #endregion

        #region Constructores

        #endregion

        #region Funciones

        /// <summary>
        /// Funcion que formatea el titular para que sea mostrado en el log
        /// </summary>
        /// <param name="titular">Instancia a ser formateada</param>
        /// <returns>Id, estatus y nombre completo</returns>
        public override string Formatear(TitularDTO titular)
        {
            return String.Format("id :\t{0}\t{1}\tNombre : {2}",
                titular.Id,
                (titular.Activo ? "Activo\t" : "Inactivo"),
                titular.Nombres + " " + titular.ApellidoPaterno + " " + titular.ApellidoMaterno);
        }//Formatear

        /// <summary>
        /// Funcion que obtiene un objeto dao que comparten todas las pruebas
        /// </summary>
        [TestFixtureSetUp]
        public void Inicializar()
        {
            XmlConfigurator.Configure(new FileInfo(ConfigurationSettings.AppSettings["log4net-config-file"]));
            IApplicationContext ctx = new XmlApplicationContext("file://DAO.xml");
            ImprimirDebug(TitularDao.INSTANCIA + ".Inicializar()");
            dao = (ITitularDao)ctx.GetObject(TitularDao.INSTANCIA);
            Assert.IsNotNull(dao, "No se pudo obtener una instancia DAO para la tabla de titulares");
        }//Inicializar

        /// <summary>
        /// Funcion que agrega datos temporales al catalogo para poder realizar pruebas
        /// </summary>
        [SetUp]
        public void AgregarDatos()
        {
            ImprimirDebug("AgregarDatos()");

            const int cantidadTitularesPrueba = 10;
            TitularDTO temp = null;

            ImprimirDebug("Titulares existentes : ", dao.Obtener());
            ImprimirDebug("Cantidad de titulares a trabajar : " + cantidadTitularesPrueba);

            for (int i = 0; i < cantidadTitularesPrueba; i++)
            {
                temp = new TitularDTO()
                {
                    Nombres = NOMBRES,
                    ApellidoPaterno = APELLIDO_PATERNO,
                    ApellidoMaterno = APELLIDO_MATERNO,
                };
                if (dao.Agregar(ref temp) )
                {
                    if (i % 2 == 1)
                    {
                        temp.Activo = false;
                        dao.Actualizar(temp);
                    }
                }
            }

            ImprimirDebug("Titulares iniciales: ", dao.Obtener());
        }//AgregarDatos

        /// <summary>
        /// Funcion que elimina los datos temporales del catalogo utilizados para las pruebas
        /// </summary>
        [TearDown]
        public void EliminarDatos()
        {
            ImprimirDebug("EliminarDatos()");

            foreach (TitularDTO titular in dao.Obtener())
            {
                if(titular.Nombres.Equals(NOMBRES) && titular.ApellidoPaterno.Equals(APELLIDO_PATERNO) 
                    && titular.ApellidoMaterno.Equals(APELLIDO_MATERNO)){
                        dao.Eliminar(titular);
                }
            }
            
            if (dao.ObtenerCantidad() == 0)
            {
                dao.ResetearId();
            }
            else
            {
                ImprimirDebug("Titulares finales : ", dao.Obtener());
            }
        }//EliminarDatos

        #endregion

        #region IGenericoDao

        /// <summary>
        /// Valida que se pueda agregar titulares a la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda agregar titulares a la capa de persistencia")]
        [Category("IGenericoDao")]
        public void Agregar()
        {
            ImprimirDebug("Agregar()");
            DateTime inicio = DateTime.Now;

            int cantidadAntes = dao.ObtenerCantidad();
            TitularDTO titularPrueba = new TitularDTO()
            {
                Nombres = NOMBRES,
                ApellidoPaterno = APELLIDO_PATERNO,
                ApellidoMaterno = APELLIDO_MATERNO,
            };
            Assert.IsNotNull(titularPrueba, "No se pudo inicializar los campos para el objeto a ser agregado");
            Assert.IsTrue(dao.Agregar(ref titularPrueba), "Ha ocurrido algun error al intentar agregar un titular");
            ImprimirDebug("Titular agregado: ", titularPrueba);
            Assert.Greater(dao.ObtenerCantidad(), cantidadAntes, "No se vario la cantidad de titulares despues de la accion de agregar");

            //Restauracion de datos
            ImprimirDebug("Eliminando titular de prueba");
            Assert.IsTrue(dao.Eliminar(titularPrueba), "No se pudo eliminar el titular que fue agregado en la prueba");

            ImprimirDebug("Titulares restantes : " + dao.ObtenerCantidad());
            ImprimirDebug("Duracion : " + (DateTime.Now - inicio).TotalSeconds + " seg.");
        }//Agregar

        /// <summary>
        /// Valida que se pueda agregar varios titulares a la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda agregar varios titulares a la capa de persistencia")]
        [Category("IGenericoDao")]
        public void AgregarVarios()
        {
            ImprimirDebug("AgregarVarios()");
            DateTime inicio = DateTime.Now;

            int cantidadAntes = dao.ObtenerCantidad();
            const int cantidadTitularesAgregar = 5;

            ImprimirDebug("Cantidad de titulares a agregar: " + cantidadTitularesAgregar);
            TitularDTO[] titulares = new TitularDTO[cantidadTitularesAgregar];
            TitularDTO temp = null;
            for (int i = 0; i < titulares.Length; i++)
            {
                temp = new TitularDTO()
                {
                    Nombres = NOMBRES,
                    ApellidoPaterno = APELLIDO_PATERNO,
                    ApellidoMaterno = APELLIDO_MATERNO,
                };
                titulares[i] = temp;
            }

            Assert.IsNotEmpty(titulares, "No se pudo inicializar los titulares a ser agregados");
            Assert.AreEqual(dao.Agregar(ref titulares), titulares.Length, "Ha ocurrido algun error al intentar agregar los titulares");
            ImprimirDebug("Titulares agregados: ", titulares);
            Assert.Greater(dao.ObtenerCantidad(), cantidadAntes, "No se vario la cantidad de titulares despues de la accion de agregar");

            //Restauracion de datos
            ImprimirDebug("Eliminando titulares de prueba");
            Assert.AreEqual(dao.Eliminar(titulares), titulares.Length, "No se pudo eliminar los titulares que fueron utilizados en la prueba");

            ImprimirDebug("Titulares restantes : " + dao.ObtenerCantidad());
            ImprimirDebug("Duracion : " + (DateTime.Now - inicio).TotalSeconds + " seg.");
        }//AgregarVarios

        /// <summary>
        /// Valida que se pueda eliminar un titular de la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda eliminar un titular de la capa de persistencia")]
        [Category("IGenericoDao")]
        public void Eliminar()
        {
            ImprimirDebug("Eliminar()");
            DateTime inicio = DateTime.Now;

            int cantidadAntes = dao.ObtenerCantidad();
            TitularDTO titularPrueba = dao.Obtener()[0];

            Assert.IsNotNull(titularPrueba, "No se pudo obtener el titular para ser eliminado");
            ImprimirDebug("Titular a ser eliminado : ", titularPrueba);
            Assert.IsTrue(dao.Eliminar(titularPrueba), "Ha ocurrido algun error al intentar eliminar un titular");
            Assert.Less(dao.ObtenerCantidad(),  cantidadAntes, "No se vario la cantidad de titulares despues de la accion de eliminar");

            ImprimirDebug("Titulares restantes : " + dao.ObtenerCantidad());
            ImprimirDebug("Duracion : " + (DateTime.Now - inicio).TotalSeconds + " seg.");
        }//Eliminar

        /// <summary>
        /// Valida que se pueda eliminar varios titulares a la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda eliminar varios titulares a la capa de persistencia")]
        [Category("IGenericoDao")]
        public void EliminarVarios()
        {
            ImprimirDebug("EliminarVarios()");
            DateTime inicio = DateTime.Now;

            int cantidadAntes = dao.ObtenerCantidad();
            TitularDTO[] titularesPrueba = dao.ObtenerInactivos();

            Assert.IsNotEmpty(titularesPrueba, "No se pudieron obtener titulares inactivos para ser eliminados");
            ImprimirDebug("Titulares a ser eliminados : ", titularesPrueba);
            Assert.AreEqual(dao.Eliminar(titularesPrueba), titularesPrueba.Length, "Ha ocurrido algun error al intentar eliminar los titulares");
            Assert.Less(dao.ObtenerCantidad(), cantidadAntes, "No se vario la cantidad de titulares despues de la accion de eliminar");

            ImprimirDebug("Titulares restantes : " + dao.ObtenerCantidad());
            ImprimirDebug("Duracion : " + (DateTime.Now - inicio).TotalSeconds + " seg.");
        }//EliminarVarios

        /// <summary>
        /// Valida que se pueda obtener un titular a partir de su identificador
        /// </summary>
        [Test(Description = "Valida que se pueda obtener un titular a partir de su identificador")]
        [Category("IGenericoDao")]
        public void ObtenerPorId()
        {
            ImprimirDebug("ObtenerPorId()");
            DateTime inicio = DateTime.Now;

            TitularDTO titularPrueba = dao.Obtener(ID);

            Assert.IsNotNull(titularPrueba, "No se pudo obtener el titular con el identificador : " + ID);
            ImprimirDebug("Titular obtenido: ", titularPrueba);

            ImprimirDebug("Duracion : " + (DateTime.Now - inicio).TotalSeconds + " seg.");
        }//ObtenerPorId

        /// <summary>
        /// Valida que se pueda obtener todos los titulares de la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda obtener todos los titulares de la capa de persistencia")]
        [Category("IGenericoDao")]
        public void ObtenerTodos()
        {
            ImprimirDebug("ObtenerTodos()");
            DateTime inicio = DateTime.Now;

            TitularDTO[] titularesPrueba = dao.Obtener();

            Assert.IsNotEmpty(titularesPrueba, "No se pudo obtener algun titular de la capa de persistencia");
            ImprimirDebug("Titulares obtenidos: ", titularesPrueba);
            Assert.AreEqual(titularesPrueba.Length, dao.ObtenerCantidad(), "No se pudo obtener todos los titulares de la capa de persistencia");

            ImprimirDebug("Duracion : " + (DateTime.Now - inicio).TotalSeconds + " seg.");
        }//ObtenerTodos

        /// <summary>
        /// Valida que se pueda actualizar un titular en la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda actualizar un titular en la capa de persistencia")]
        [Category("IGenericoDao")]
        public void Actualizar()
        {
            ImprimirDebug("Actualizar()");
            DateTime inicio = DateTime.Now;

            const string nuevoNombre = "Actualizar";
            string antiguoNombre;

            TitularDTO titularPrueba = dao.Obtener(ID);
            Assert.IsNotNull(titularPrueba, "No se pudo obtener un titular para ser modificado");
            
            antiguoNombre = titularPrueba.Nombres;
            titularPrueba.Nombres = nuevoNombre;
            Assert.IsTrue(dao.Actualizar(titularPrueba), "No se pudo actualizar el titular de prueba");
            ImprimirDebug("Titular actualizado: ", titularPrueba);

            titularPrueba = dao.Obtener(ID);
            Assert.AreEqual(titularPrueba.Nombres, nuevoNombre, "No se pudo actualizar el nombre del titular en la capa de persistencia");

            //Restauracion de datos
            ImprimirDebug("Eliminando datos actualizados");
            Assert.IsTrue(dao.Eliminar(titularPrueba), "No se pudo eliminar el titular actualizado");

            ImprimirDebug("Duracion : " + (DateTime.Now - inicio).TotalSeconds + " seg.");
        }//Actualizar

        /// <summary>
        /// Valida que se pueda actualizar un conjunto de titulares en la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda actualizar un conjunto de titulares en la capa de persistencia")]
        [Category("IGenericoDao")]
        public void ActualizarVarios()
        {
            ImprimirDebug("ActualizarVarios()");
            DateTime inicio = DateTime.Now;

            const string nuevoNombre = "Actualizar";

            int cantidadAntes = dao.ObtenerCantidad();
            TitularDTO[] titularesPrueba = dao.ObtenerInactivos();
            Assert.IsNotEmpty(titularesPrueba, "No se pudo obtener el conjunto de titulares a actualizar");
            ImprimirDebug("Titulares a ser actualizados:", titularesPrueba);

            foreach(TitularDTO titular in titularesPrueba)
            {
                titular.Nombres = nuevoNombre;
            }
            Assert.AreEqual(dao.Actualizar(titularesPrueba), titularesPrueba.Length, "Ha ocurrido algun error al intentar actualizar los titulares");

            titularesPrueba = dao.ObtenerInactivos();
            ImprimirDebug("Titulares actualizados:", titularesPrueba);
            Assert.IsNotEmpty(titularesPrueba, "No se pudo obtener el conjunto de titulares actualizados");

            //Comprobacion de datos actualizados
            ImprimirDebug("Comprobacion de datos actualizados");
            foreach (TitularDTO titular in titularesPrueba)
            {
                Assert.AreEqual(titular.Nombres, nuevoNombre, "No se pudo actualizar el nombre del titular con id = " + titular.Id + "en la capa de persistencia");
                
            }

            //Restauracion de datos
            Assert.AreEqual(dao.Eliminar(titularesPrueba), titularesPrueba.Length, "No se pudo eliminar los titulares de prueba");

            ImprimirDebug("Duracion : " + (DateTime.Now - inicio).TotalSeconds + " seg.");
        }//ActualizarVarios

        /// <summary>
        /// Valida que se pueda validar si existe un titular en particular
        /// </summary>
        [Test(Description = "Valida que se pueda validar si existe un titular en particular")]
        [Category("IGenericoDao")]
        public void Existe()
        {
            ImprimirDebug("Existe()");
            DateTime inicio = DateTime.Now;

            TitularDTO titularExistente = dao.Obtener(ID);
            Assert.IsNotNull(titularExistente, "No se pudo obtener el titular con el identificador : " + ID);
            ImprimirDebug("Titular obtenido: ", titularExistente);
            Assert.IsTrue(dao.Existe(titularExistente), "No se pudo encontrar un titular extraido de la capa de persistencia");

            TitularDTO titularInexistente = new TitularDTO();
            titularInexistente.Id = -1;
            Assert.IsFalse(dao.Existe(titularInexistente), "Se encontro un titular ficticio en la capa de persistencia");

            ImprimirDebug("Duracion : " + (DateTime.Now - inicio).TotalSeconds + " seg.");
        }//Existe

        /// <summary>
        /// Valida que se pueda resetear el identificador autoincremental
        /// </summary>
        [Test(Description = "Valida que se pueda resetear el identificador autoincremental")]
        [Category("IGenericoDao")]
        public void ResetearId()
        {
            ImprimirDebug("ResetearId()");
            DateTime inicio = DateTime.Now;

            TitularDTO[] titulares = dao.Obtener();
            Assert.IsNotEmpty(titulares, "No se pudieron obtener todos los titulares de la capa de persistencia");

            int ultimoId = titulares[titulares.Length - 1].Id;
            ImprimirDebug("El valor del ultimo Id es : " + ultimoId); 
            Assert.Greater(ultimoId, 0, "El ultimo identificador del catalogo de titulares no es mayor a cero");

            //Vacio la tabla
            Assert.AreEqual(dao.Eliminar(titulares), titulares.Length, "Ha ocurrido algun error al intentar eliminar los titulares");
            dao.ResetearId();

            TitularDTO titularPrueba = new TitularDTO()
            {
                Nombres = "ResetearId",
                ApellidoPaterno = "ResetearId",
                ApellidoMaterno = "ResetearId",
            };
            Assert.IsTrue(dao.Agregar(ref titularPrueba), "No se pudo agregar el titular de prueba al catalogo");
            ImprimirDebug("Se ha agregado el titular : ", titularPrueba);

            titulares = dao.Obtener();
            ImprimirDebug("Titulares actuales en el catalogo : ", titulares);
            Assert.IsNotEmpty(titulares, "No se pudieron obtener todos los titulares de la capa de persistencia");
            ImprimirDebug("El valor del ultimo Id es : " + titulares[titulares.Length - 1].Id);
            Assert.Less(titulares[titulares.Length - 1].Id, ultimoId, "El id reseteado es mayor o igual al anterior");
            Assert.AreEqual(titulares[titulares.Length - 1].Id, 1, "El ultimo id no es igual a uno");

            Assert.IsTrue(dao.Eliminar(titularPrueba), "No se pudo eliminar el titular de prueba al catalogo");
            ImprimirDebug("Duracion : " + (DateTime.Now - inicio).TotalSeconds + " seg.");
        }//ResetearId

        /// <summary>
        /// Valida que se pueda obtener la cantidad de registros del catalogo de titulares en la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda obtener la cantidad de registros del catalogo de titulares en la capa de persistencia")]
        [Category("IGenericoDao")]
        public void ObtenerCantidad()
        {
            ImprimirDebug("ObtenerCantidad()");
            DateTime inicio = DateTime.Now;

            int cantidad = dao.ObtenerCantidad();
            ImprimirDebug("Cantidad obtenida mediante ObtenerCantidad() : " + cantidad);
            TitularDTO[] titulares = dao.Obtener();
            ImprimirDebug("Cantidad obtenida mediante Obtener() : " + titulares.Length);

            Assert.AreEqual(titulares.Length, cantidad, "La cantidad de titulares no coincide");
            ImprimirDebug("Duracion : " + (DateTime.Now - inicio).TotalSeconds + " seg.");
        }//ObtenerCantidad

        #endregion

        #region IActivo

        /// <summary>
        /// Valida que se puedan obtener todos los titulares activos de la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se puedan obtener todos los titulares activos de la capa de persistencia")]
        [Category("IActivo")]
        public void ObtenerActivos()
        {
            ImprimirDebug("ObtenerActivos()");
            DateTime inicio = DateTime.Now;

            TitularDTO[] titulares = dao.ObtenerActivos();
            ImprimirDebug("Titulares obtenidos : ", titulares);

            Assert.IsNotEmpty(titulares, "No existen titulares activos o no se pudo obtener un conjunto de titulares activos");
            ImprimirDebug("Duracion : " + (DateTime.Now - inicio).TotalSeconds + " seg.");
        }//ObtenerActivos

        /// <summary>
        /// Valida que se puedan obtener todos los titulares inactivos de la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se puedan obtener todos los titulares inactivos de la capa de persistencia")]
        [Category("IActivo")]
        public void ObtenerInactivos()
        {
            ImprimirDebug("ObtenerInactivos()");
            DateTime inicio = DateTime.Now;

            TitularDTO[] titulares = dao.ObtenerInactivos();
            ImprimirDebug("Titulares obtenidos : ", titulares);

            Assert.IsNotEmpty(titulares, "No existen titulares activos o no se pudo obtener un conjunto de titulares inactivos");
            ImprimirDebug("Duracion : " + (DateTime.Now - inicio).TotalSeconds + " seg.");
        }//ObtenerInactivos

        /// <summary>
        /// Valida que se pueda activar un titular en la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda activar un titular en la capa de persistencia")]
        [Category("IActivo")]
        public void Activar()
        {
            ImprimirDebug("Activar()");
            DateTime inicio = DateTime.Now;

            TitularDTO[] titularesInactivos = dao.ObtenerInactivos();
            Assert.IsNotEmpty(titularesInactivos, "No existen titulares inactivos o no se pudo obtener un conjunto de titulares inactivos");
            ImprimirDebug("Titulares obtenidos : ", titularesInactivos);
            TitularDTO primerInactivo = titularesInactivos[0];
            TitularDTO inactivoBusqueda = null;

            Assert.IsNotNull(primerInactivo, "No se pudo obtener el primer titular inactivo del catalogo");
            ImprimirDebug("Titular a ser activado : ", primerInactivo);
            Assert.IsTrue(dao.Activar(primerInactivo), "No se puedo activar el primer titular inactivo del catalogo");

            inactivoBusqueda = dao.Obtener(primerInactivo.Id);
            Assert.IsNotNull(inactivoBusqueda, "No se pudo obtener el titular con su nuevo estatus de activo");
            ImprimirDebug("Titular activado : ", inactivoBusqueda);
            Assert.IsTrue(inactivoBusqueda.Activo, "No se pudo actualizar el estatus del titular : " + inactivoBusqueda.Nombres + " " + inactivoBusqueda.ApellidoPaterno + " " + inactivoBusqueda.ApellidoMaterno);

            ImprimirDebug("Duracion : " + (DateTime.Now - inicio).TotalSeconds + " seg.");
        }//Activar

        /// <summary>
        /// Valida que se pueda desactivar un titular en la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda desactivar un titular en la capa de persistencia")]
        [Category("IActivo")]
        public void Desactivar()
        {
            ImprimirDebug("Desactivar()");
            DateTime inicio = DateTime.Now;

            TitularDTO[] titularesActivos = dao.ObtenerActivos();
            Assert.IsNotEmpty(titularesActivos, "No existen titulares activos o no se pudo obtener un conjunto de titulares activos");
			ImprimirDebug("Titulares obtenidos : ", titularesActivos);
            TitularDTO activoBusqueda = null;
            TitularDTO primerActivo = titularesActivos[0];

            Assert.IsNotNull(primerActivo, "No se pudo obtener el primer titular activo del catalogo");
            ImprimirDebug("Titular a ser inactivado : ", primerActivo);
            Assert.IsTrue(dao.Desactivar(primerActivo), "No se puedo desactivar el primer titular activo del catalogo");

            activoBusqueda = dao.Obtener(primerActivo.Id);
            Assert.IsNotNull(activoBusqueda, "No se pudo obtener el titular con su nuevo estatus de inactivo");
            ImprimirDebug("Titular inactivado : ", activoBusqueda);
            Assert.IsFalse(activoBusqueda.Activo, "No se pudo actualizar el estatus del titular : " + activoBusqueda.Nombres + " " + activoBusqueda.ApellidoPaterno + " " + activoBusqueda.ApellidoMaterno);

            ImprimirDebug("Duracion : " + (DateTime.Now - inicio).TotalSeconds + " seg.");
        }//Desactivar

        #endregion

    }//TitularDao
}//Electrocucaracha.AdminPersonal.DAO.Test